package com.shujujiegou.数组.用类封装数组实现数据结构;

import java.util.Arrays;

/**
 * 背景：①、如何插入一条新的数据项
 *
 * 　　②、如何寻找某一特定的数据项
 *
 * 　　③、如何删除某一特定的数据项
 *
 * 　　④、如何迭代的访问各个数据项，以便进行显示或其他操作
 *
 * 　　而我们知道了数组的简单用法，现在用类的思想封装一个数组，
 *     实现上面的四个基本功能：
 *
 * 　　ps:假设操作人是不会添加重复元素的，这里没有考虑重复元素，
 *        如果添加重复元素了，后面的查找，删除，修改等操作只会对第一次出现的元素有效。
 */
public class MyArray<T> {
    // 定义一个数组
    private T[] array;
    // 数组的实际长度
    private int conCurentLength;
    // 数组的最大长度
    private int length;

    public MyArray() {
        // 默认构造一个长度为50的数组
        this.conCurentLength = 0;
        this.length = 50;
        this.array = (T[])new Object[length];
    }

    public MyArray(int length) {
        this.conCurentLength = 0;
        this.length = length;
        this.array = (T[])new Object[length];
    }

    /**
     * 获取数组的有效长度
     */
    public int getSize() {
        return conCurentLength;
    }

    /**
     * 遍历显示元素
     */
    public void display() {
        // for循环遍历
        for(int i = 0 ; i < conCurentLength; ++i) {
            System.out.print(array[i] + " ");
        }

        System.out.println();

        // Arrays工具类的toString方法
        // System.out.println(Arrays.toString(array));

        // 采用foreach
        /*for(T t : array) {
            System.out.print(t);
        }*/
    }

    /**
     * 添加元素
     * @param value ,假设操作人是不会添加重复元素的，如果有重复元素对于后面的操作都会有影响。
     * @return 添加成功返回true,添加的元素超过范围了返回false
     */
    public boolean add(T value) {
        if(conCurentLength < length) {
            array[conCurentLength] = value;
            conCurentLength++;
        } else {
            return false;
        }

        return true;
    }

    // 查找元素
    public T get(int i) {
        if(i < 0 && i >= length) {
            System.out.println("数组越界");
        }

        return array[i];
    }

    /**
     * 查找元素
     * @param targetValue
     * @return 查找的元素如果存在则返回下标值，如果不存在，返回 -1
     */
    public int find(T targetValue) {
        int i = -1;
        for(int k = 0; k < conCurentLength; ++k) {
            if(array[k] == targetValue) {
                i = k;
                break;
            }
        }

        return i;
    }

    /**
     * 删除元素
     * @param value
     * @return 如果要删除的值不存在，直接返回 false;否则返回true，删除成功
     */
    public boolean delete(T value) {
        int k = find(value);
        if(k == -1) {
            return false;
        } else {
            if(k == (conCurentLength - 1)) {
                conCurentLength --;
            } else {
                for(int i= k; i < conCurentLength -1; ++i) {
                    array[i] = array[i + 1];
                }

                conCurentLength --;
            }
        }

        return true;
    }

    /**
     * 修改数据
     * @param oldValue
     * @param newValue
     * @return 修改成功返回true，修改失败返回false
     */
    public boolean update(T oldValue, T newValue) {
        int i = find(oldValue);
        if(i == -1) {
            System.out.println("需要修改的数据不存在！");
            return false;
        } else {
            array[i] = newValue;
        }

        return true;
    }
}
